Whiteline: delta/whiteline CD Series - delta.iso/tools/anwender/calc/calc_pd.doc

Text File | 1995-11-25 | 32KB | 838 lines

             Programmbeschreibung:  CALC_13.TOS



File:            CALC_PD.DOC

Autor:           G. Schnell       Tel: 0531 - 693058
                 Dachdeckerweg 19
                 38126 Braunschweig

Entwickelt mit:  ATARI 1040 STFM 4MB,  TOS 2.06

Compiler:        Prospero Fortran 77,  Version 2.165

Programmstart:   als CALC_13.TOS unter TOS oder Multi-TOS

13  :            Max. Anzahl Dezimalstellen der CALC-Version

benötigte
Hardware:        ST, STE, TT, FALCON   1 MB

Auflösung:       640 * 400  monochrom

benötigte
Software:        ASCII-Editor




Name der Ausgabe-Datei:     CALC.LS


Namen der Eingabe-Dateien:  xxxxxxxx.IN
                            xxxxxxxx.DAT



Kurzbeschreibung:

Simulation eines programmierbaren Taschenrechners
mit Ein- und Ausgabemöglichkeiten und wählbarer
Genauigkeit.
C..NP
               Starten und Beenden von CALC

CALC verlangt beim Start eine arithmetische Anweisung als Passwort.
Bei fehlerhafter Angabe des Passwortes wird CALC sofort beendet.
Falls Sie eine eingeschränkte PD-Version von CALC besitzen, geben Sie
den Zeichenstring PI und Return ein.

Sie beenden CALC durch Eingabe von  BY  in der Eingabezeile und
anschließendem Drücken der Return Taste.



               Ausdruck dieser Programmbeschreibung

Starten Sie das Programm F_PRN.TTP und geben Sie in der erscheinen-
den Box den String calc_pd.doc ein. F_PRN.TTP gibt diese Beschreibung
im ASCII-Modus auf Drucker aus. Zumindest auf dem HP Deskjet
funktioniert das.



               Fehlerhandling in CALC

CALC versucht Fehler abzufangen.
Im Fehlerfall werden Fehlermeldungen in der Ergebniszeile ausgegeben.

Beliebte Fehler sind:

a) Benutzen von Stackvariablen ohne Wert.
b) Falsche Anzahl von Argumenten in Funktionen.
c) Benutzen von Semikolon oder einzelnen Hochkommata innerhalb
   von Doppelhochkommata.



               CALC unter MULTITOS

a) Falls CALC um eine Zeile falsch positioniert, dann spendieren
   Sie TOSWIN 26 statt 25 Zeilen für sein Fenster.

b) Falls Sie Ausgaben auf CALC.LS getätigt haben, sollten Sie
   CALC nicht durch Schließen des Fensters ( Schlie0knopf oben
   links ) verlassen. Die Datei CALC.LS geht verloren, es sei denn,
   Sie geben vorher den Befehl CLOSELS .
C..NP
                    Überblick

CALC ist als interpretierender Taschenrechner mit Ein- und
Ausgabemöglichkeiten und wählbarer Genauigkeit geschrieben.
Das Programm benutzt eine eigene Arithmetik für große
Zahlen. Die Mantissenlänge ist in der Vollversion von
13 bis 999 Dezimalstellen einstellbar. Der Exponent reicht
von 10^-16380 bis 10^16380.
Das Programm interpretiert Formeln nach mathematischen Regeln
und bietet eine Fülle von Möglichkeiten.
Die Reihenfolge der Formelauswertung ist nicht unbedingt von
links nach rechts! Eine bestimmte Reihenfolge der Auswertung
kann jedoch durch Setzen von Klammern erzwungen werden.
Im Ausdruck  ( 4 + ( 2 + 1 ) )  wird zuerst 2+1=3 und dann
4+3=7 gerechnet.

Hier eine kleine Aufzählung:

   Konstanten im allgemeinen Dezimalformat, im Oktalformat,
   im Hexadezimalformat, im Binärformat und im ASCII-Format
   PI und EU als Mnemonics
   die üblichen mathematischen Funktionen
   spezielle Funktionen für große Zahlen

Variablen für rechte und linke Seite von arith. Anweisungen:
Stackvariablen A bis H
Variablen I bis Z
Vektorvariablen K(i), XR(i) und XI(i) ( i = 1 bis 99 )
Selbst definierte Variablen mit 2 bis 31 Zeichen

Matrizen ansprechbar mit ASCII-Konstanten 'A' bis 'Z'

Textvariable ansprechbar mit ASCII-Konstanten 'A' bis 'Z'

Ausgabe von Ergebnissen auf Datei

Eingabe von Daten aus Datei
( insbesondere große Zahlen und Matrizen )

Eingabe von Anweisungen aus Datei
Es existieren Interpreteranweisungen für DO-Schleifen,
IF - ELSE IF - ELSE - END IF Strukturen, GO TO, Input, Output
und andere Befehle.

Der Interpreter wurde für einfaches Rechnen mit großen
Zahlen geschrieben, ist aber auch als Taschenrechner gut
zu gebrauchen. Er ist gut ausgetestet.

Auf Grund der vielen Möglichkeiten des Interpreters, der intensiven
ASCII-Verarbeitung und der eigenen Arithmetik fehlt es jedoch
zuweilen an Geschwindigkeit.
C..NP
         Einführung in die Arbeitsweise von CALC

CALC verarbeitet Eingabezeilen mit einer max. Länge von 76 Zeichen.
Die Eingabezeilen kommen entweder aus Dateien oder aus dem Zeilen-
editor von CALC. CALC separiert diese Eingabezeilen in Anweisungen.
Als Separator dient das Semikolon.
Beim Start befindet sich CALC im Append-Modus. In diesem Modus ist
die APPEND-Anweisung erlaubt. Die APPEND-Anweisung liest aus Dateien
mit der Extension .IN Anweisungen. Diese Anweisungen werden in einem
Ringspeicher, jeweils ans Ende von schon bestehenden, noch nicht ab-
gearbeiteten Anweisungen abgelegt. Aus diesem Speicher werden nach
dem Prinzip First In - First Out ( FIFO ) Eingabezeilen ausgelesen,
separiert, ausgeführt und freigegeben. Mit Hilfe der APPEND-An-
weisung lassen sich beliebig große Programme schreiben. Zur Zeit
haben im FIFO 100 Eingabezeilen Platz.
Die EXEC-Anweisung liest aus einer Datei mit der Extension .IN ein
Programm und die zugehörigen Unterprogramme in einen eigenen EXEC-
Speicher ein. CALC wechselt in den EXEC-Modus, führt das Programm
aus und wechselt in den APPEND-Modus zurück. Im EXEC-Modus kennt
CALC zusätzliche Befehle( z.B.: DO-Schleifen, IF ENDIF Strukturen )
aber nicht die APPEND-Anweisung. Im EXEC-Speicher haben zur Zeit
mindestens 325, aber höchstens 1000 separierte Anweisungen Platz.


Hinweis zur Arbeitsweise von CALC beim Wechsel der Stellenzahl:

CALC wechselt intern die Stellenzahl in Schritten von 4 Dezimal-
stellen. Beim Wechsel auf eine höhere Stellenzahl werden alle
aktuellen Variablenmantissen mit Nullen aufgefüllt. Beim Wechsel
auf eine niedrigere Stellenzahl werden alle aktuellen Variablen-
mantissen gekürzt! Bei einem erneuten Wechsel auf eine höhere
Stellenzahl sind die gekürzten Mantissenstellen verloren!
C..NP
               Beschreibung des Menüs

Die unteren Tasten des Menüs betätigt man durch Drücken der 10
Funktionstasten. Die obere Tastenreihe erreicht man durch gleich-
zeitiges Drücken der Shift-Taste mit einer Funktionstaste.
Zur Kontrolle wird das zuletzt angewählte Funktionsfeld gedimmt
oder seine Anzeige geändert.

Wesentlich beim Arbeiten mit CALC ist der Stack mit
seinen Variablen A, B, C, D, E, F, G und H.

Durch Eingabe von arithmetischen Ausdrücken ohne Gleichheits-
zeichen baut sich der Stack auf.
Durch Drücken von bestimmten Funktionstasten
baut sich der Stack ab.
Schon hier sei gesagt, daß jede Funktionstaste eine equivalente
Interpreteranweisung besitzt.
Der Interpreter beherrscht jedoch viele zusätzliche Anweisungen.
Der Interpreter baut den Stack nicht ab. Dies ist nur mit
den speziellen Anweisungen CLEAR oder CLEARALL möglich.
Falls der Stack mit seinen Variablen A bis H gefüllt ist, so
bewirkt eine arithmetische Anweisung ohne das Gleichheitszeichen,
einen Stacküberlauf. Der Stack wird gescrollt. Der neue Wert wird
in H abgelegt. Der Wert in A geht verloren.
Eine Stackvariable mit einem Wert kann jederzeit rechts und links
vom Gleichheitszeichen einer Anweisung benutzt werden. Die erste
freie Stackvariable darf links vom Gleichheitszeichen auftreten.

erg-key:
Der Wert der letzten belegten Stackvariablen wird in der Ergebnis-
zeile angezeigt. Falls der Loff/Lon-key auf Lon steht, wird das Er-
gebnis ebenfalls in der Datei CALC.LS protokolliert. Es wird die
Stellenanzahl aus L=nn ( nn=13 am Start ) benutzt.

strg-key:
Der momentane Inhalt der Eingabezeile wird auf der Datei CALC.LS
ausgegeben, falls der Loff/Lon-key auf Lon steht.

txt1-key, txt2-key, txt3-key:
Der momentane Inhalt der Eingabezeile wird zwischengespeichert. Der
gespeicherte Text kann jederzeit mit dem rechts daneben liegenden
call-key in die Eingabezeile kopiert werden.

exch-key:
Der Inhalt der beiden letzten Stackvariablen wird vertauscht.

C-key:
Die letzte belegte Stackvariable wird freigegeben.

CA-key:
Alle belegten Stackvariablen werden freigegeben.

Help-key:
Die Helptaste ist ein Umschalter. Mit ihr lassen sich die Inhalte
der Variablen I bis Z anzeigen.
C..NP
               Beschreibung des Menüs

set/edit-key:
Umschalten in Set-Modus oder Edit-Modus für Oktal-,Hexadezimal-,
Binär- und ASCII-Konstanten.

K=nn-key:
Im Set-Modus werden Oktalkonstanten reihum als 4-, 8-, 16- oder
32-Bit-Konstanten definiert.
Im Edit-Modus wird der Wert der letzten belegten Stackvariablen
in der Ergebniszeile als Oktalkonstante angezeigt.
Falls der Loff/Lon-key auf Lon steht, wird das Ergebnis
ebenfalls in der Datei CALC.LS protokolliert. Es wird die
Bitanzahl aus K=nn benutzt.

Z=nn-key:
Im Set-Modus werden Hexadezimalkonstanten reihum als 4-, 8-, 16-
oder 32-Bit-Konstanten definiert.
Im Edit-Modus wird der Wert der letzten belegten Stackvariablen
in der Ergebniszeile als Hexadezimalkonstante angezeigt.
Falls der Loff/Lon-key auf Lon steht, wird das Ergebnis
ebenfalls in der Datei CALC.LS protokolliert. Es wird die
Bitanzahl aus Z=nn benutzt.

B=nn-key:
Im Set-Modus werden Binärkonstanten reihum als 4-, 8-, 16- oder
32-Bit-Konstanten definiert.
Im Edit-Modus wird der Wert der letzten belegten Stackvariablen
in der Ergebniszeile als Binärkonstante angezeigt.
Falls der Loff/Lon-key auf Lon steht, wird das Ergebnis
ebenfalls in der Datei CALC.LS protokolliert. Es wird die
Bitanzahl aus B=nn benutzt.

A=nn-key:
Im Set-Modus werden ASCII-Konstanten reihum als 8-, 16-, 24- oder
32-Bit-Konstanten definiert.
Im Edit-Modus wird der Wert der letzten belegten Stackvariablen
in der Ergebniszeile als ASCII-Konstante, EBCDIC-Konstante und als
Oktalkonstante angezeigt.
Falls der Loff/Lon-key auf Lon steht, wird das Ergebnis
ebenfalls in der Datei CALC.LS protokolliert. Es wird die
Bitanzahl aus A=nn benutzt.
C..NP
               Beschreibung des Menüs

Rad/Grad-key:
Umschalten in Radian-Modus oder Grad-Modus.
Im Radian-Modus werden die Argumente der Funktionen SIN, COS und
TAN in Radian interpretiert. Die Ergebnisse der Funktionen ASIN,
ACOS und ATAN werden in Radian bestimmt.
Im Grad-Modus werden die Argumente der Funktionen SIN, COS und
TAN in Grad interpretiert. Die Ergebnisse der Funktionen ASIN,
ACOS und ATAN werden in Grad bestimmt.

L=nn-key:
Der letzte im Stack stehende Wert wird als nn übernommen. nn muß
im Bereich 1 bis 999 liegen und ganzzahlig sein. Nach der Über-
nahme wird die entsprechende Stackvariable freigegeben.
Die Funktion ERG( arg ) gibt das Argument arg mit nn Stellen auf
CALC.LS aus, falls der Loff-/Lon-key auf Lon steht ( siehe auch
erg-key ).

D=nn-key:
Der letzte im Stack stehende Wert wird als nn übernommen. nn muß
im Bereich 13 bis 999 liegen und ganzzahlig sein. Nach der Über-
nahme wird die entsprechende Stackvariable freigegeben.
Ab sofort rechnet CALC mit nn Dezimalstellen.

Loff/Lon-key:
Umschalten in den LISTON-Modus oder den LISTOFF-Modus. Im LISTON-
Modus kann auf verschiedene Arten auf die Datei CALC.LS ausgegeben
werden. Beim ersten LISTON wird CALC.LS als Datei geöffnet. Falls
CALC.LS schon existiert, so werden Ausgaben an die Datei angefügt.
Ein LISTOFF nach einem LISTON sperrt die Datei CALC.LS, schließt
sie aber nicht. Mit der Anweisung CLOSELS wird die Datei CALC.LS
geschlossen.
C..NP
             Editieren Interpreteranweisungen

CALC besitzt eine Eingabezeile und eine Ausgabezeile.
Der Cursor steht stets in der Eingabezeile.

In der Eingabezeile editiert der Benutzer seine Eingaben.
Folgende Tasten stehen zum Editieren zur Verfügung:

Arrow Left    Cursor eine Stelle nach links
Arrow Right   Cursor eine Stelle nach rechts
Clr Home      Setzen Cursor an den Anfang der Eingabezeile
Backspace     Löschen Zeichen links vom Cursor
Delete        Löschen Zeichen unter dem Cursor
Insert        Umschalter: insert ein / insert aus; Anzeige am Rand !
Return/Enter  Ausführen einer editierten Anweisung
CTRL E        Löschen Rest der Eingabezeile ab Cursorposition
CTRL R        Springen nach rechts von Wort zu Wort
CTRL L        Springen nach links  von Wort zu Wort
CTRL A        Kopieren letzte Eingabe oder Cursor ans Ende vom Text
CTRL Delete   Löschen Text in Eingabezeile, Speichern in Undo-Buffer
Undo          Holen die letzten 10 mit CTRL-Delete gelöschten Texte
              in Eingabezeile
CTRL Q        Holen die letzten 10 mit Return/Enter eingegebenen
              unterschiedlichen Texte in Eingabezeile

Es stehen alle druckbaren Zeichen in Groß- und Kleinschreibung und das
Leerzeichen (Space) zur Verfügung.

Mehrere Anweisungen pro Eingabezeile sind duch Semikolon
zu trennen.


In der Ausgabezeile erscheinen Fehlermeldungen und bestimmte
Ergebnisse.

C..NP
             Systemanweisungen für den Interpreter

Anweisungen sind in Groß- oder Kleinschreibung
( auch gemischt ) in die Eingabezeile zu schreiben. Mehrere
Anweisungen sind durch Semikolon zu trennen. Spaces können
beliebig eingestreut werden. Return/Enter schließt die Eingabe
ab und führt die Anweisung aus.

Beginnt eine Eingabezeile mit dem Zeichenstring 'BY', so wird
CALC beendet. Der Rest der Eingabe wird nicht mehr geprüft.
Beispiel:  By1234 ...  beendet CALC.


BY         CALC beenden
by

DIR        Aktuelle directory in Ausgabezeile anzeigen
dir

WHO        Benutzernamen in Ausgabezeile anzeigen
who

TIME       Uhrzeit in Ausgabezeile anzeigen
time

DATE       Datum in Ausgabezeile anzeigen
date

BELL       Bildschirmklingel betätigen
bell



Weitere Anweisungen für den Interpreter werden später er-
läutert.

C..NP
             Arithmetische Interpreteranweisungen

Der Interpreter hält mathematische Regeln in Interpretation
und Ausführung strikt ein. Zusätzliche Erweiterungen
lehnen sich an Fortran 77 an.

CALC unterscheidet zwischen arithmetischen Ausdrücken
und arithmetischen Zuweisungen. Eine Zuweisung enthält
das Gleichheitszeichen. Sie weist einer bestimmten Variablen
( Adresse) einen Wert zu. Der Wert eines arithmetischen
Ausdrucks wird immer der nächsten freien Stackvariablen
zugewiesen. Sind alle Stackvariablen belegt, so wird der Stack
gescrollt und der Wert der letzten Stackvariablen H zuge-
wiesen. Der Inhalt der Stackvariablen A geht verloren.

In arithmetische Interpreteranweisungen dürfen beliebig viele
Spaces eingestreut werden ( Ausnahme: ASCII-Konstanten ).


Variablenvorrat des Interpreters:

a) Stackvariablen       A, B, C, D, E, F, G und H.
b) permanente Variablen I, J, K, ... , X, Y, Z.
c) Vektorvariablen      K(i), XR(i), XI(i) ( i = 1 bis 99 )
d) definierte Variablen 2 bis 31 Zeichen. Erstes Zeichen ein
                        Buchstabe. Sonst Buchstaben, Ziffern
                        und Underscore.
e) Ergebnisvariablen    PXR(i), PXI(i) ( i ist ein beliebiger Wert )
                        Ergebnisvariablen sind nur rechts vom Gleich-
                        heitszeichen verfügbar.

Variablen können links und rechts vom Gleichheitszeichen
einer Anweisung auftreten. Rekursive Anweisungen wie
A = A + B sind erlaubt. Den Stackvariablen A und B muß jedoch vorher
ein Wert zugewiesen worden sein. Die Anweisung D = A ist nur
erlaubt, wenn D schon einen Wert enthält oder D die nächste
freie Stackvariable ist. Für permanente Variablen, Vektor-
Variablen und definierte Variablen gelten diese Einschränkungen
nicht. Ihre Werte sind beim Start von CALC auf Null.

Die Vektorvariablen K(i), XR(i) und XI(i) sind links vom Gleichheits-
zeichen mit Indices anzusprechen. Die Indices sind ganzzahlige
arithmetische Ausdrücke im Bereich von 1 bis 99.

          A=INT(PI)); XR(A)  = 123.4      ist erlaubt.
          A=5;        XI(A^2)= 123.4      ist erlaubt.
                      K(3+5) = 123.4      ist erlaubt.
          A   = 3;    K(A)   = 123.4      ist erlaubt.
DEF"ABC"; ABC = 3;    K(ABC) = 123.4      ist erlaubt.
          A   = Pi;   K(A)   = 123.4      ist nicht erlaubt.
          K(1)= 3;    K(K(1))= 123.4      ist erlaubt.
C..NP
              Operatoren und Konstanten

Operatoren für arithmetische Ausdrücke:

+     Addition
-     Subtraktion
*     Multiplikation
/     Division
**    Potenzierung
^     Potenzierung

Sonderzeichen für arithmetische Ausdrücke:

(     Klammer auf
)     Klammer zu
,     Komma für Funktionen mit mehreren Veränderlichen und
      als Separator für bestimmte Formen von ASCII-Konstanten
'     Hochkomma für ASCII-Konstanten, Matrizen und Textvariable

Sonderzeichen für weitere Interpreteranweisungen:

"     Doppelhochkomma für Symbole, Text oder bedingte Anweisungen

Konstanten für arithmetische Ausdrücke:

Symbolische Konstanten:
Pi    für die Kreiskonstante 3.14 ...
Eu    für die Eulersche Zahl 2.71 ...

Dezimalkonstanten:
Alle vernünftigen Darstellungen im allgemeinen E-Format sind
erlaubt.
Die Konstanten  1, .1, 1., 1E1, .1E+1, 1.E-1  sind zulässig.
E+1 ist zulässig, wird jedoch als Addition der Stackvariablen
E und der Konstanten 1 interpretiert.

Binärkonstanten:
Die jeweils gültige Länge der Binärkonstanten wird im Set-Modus
gesetzt. Mögliche Längen sind 4 Bit, 8 Bit, 16 Bit und 32 Bit.
1111B     = -1   im 4 Bit Format.
1111B     = 15   im 8 Bit Format.

Octalkonstanten:
Die jeweils gültige Länge der Octalkonstanten wird im Set-Modus
gesetzt. Mögliche Längen sind 4 Bit, 8 Bit, 16 Bit und 32 Bit.
17K       = -1   im 4 Bit Format.
17K       = 15   im 8 Bit Format.

Hexadezimalkonstanten:
Die jeweils gültige Länge der Hexadezimalkonstanten wird im
Set-Modus gesetzt. Mögliche Längen sind 4 Bit, 8 Bit, 16 Bit
und 32 Bit.
FZ        = -1   im 4 Bit Format.
FZ        = 15   im 8 Bit Format.
C..NP
             ASCII-Konstanten

Die jeweils gültige Länge der ASCII-Konstanten wird im Set-Modus
gesetzt. Mögliche Längen sind 8 Bit, 16 Bit, 24 Bit und 32 Bit.

ASCII-Konstanten werden in Hochkommata eingeschlossen. In Ab-
hängigkeit von dem eingestellten Modus können bis zu vier
Zeichen als Argumente angegeben werden. Werden weniger Argumente
als zulässig angegeben, so werden die Argumente rechtsbündig
interpretiert (  'a' enspricht '   a'  im 32 Bit Modus ).
Nicht druckbare Zeichen können als Mnemonics oder als Oktal-
zahlen ( ohne Endung K ) durch Kommata getrennt in spitzen
Klammern eingegeben werden. Als Argument ist das Hochkomma-
Zeichen doppelt anzugeben. Die spitzen Klammern können nicht
direkt als Argumente angegeben werden. Sie sind als Mnemonics
LT und GT oder als Oktalzahlen anzugeben. Unten ist die
komplette Mnemonic-Tabelle aufgeführt.

Beispiele:
'A'            =             65 im  8 Bit Format.
'AA'           =         16 705 im 16 Bit Format.
'AAA'          =      4 276 545 im 24 Bit Format.
'AAAA'         =  1 094 795 585 im 32 Bit Format.
'a<NL,FF,12>'  =  1 628 048 394 im 32 Bit Format.
'<LT>a<GT,2>'  =  1 013 005 826 im 32 Bit Format.
'<a> '         =         24 864 im 32 Bit Format.
'<a>'          =             97 im 32 Bit Format.
''''      = 39    entspricht dem Dezimalwert eines Apostrophs.

Mnemonics für ASCII im Oktalbereich 0 bis 177.
'NUL'=000   'SOH'=001   'STX'=002   'ETX'=003   'EOT'=004
'ENQ'=005   'ACK'=006   'BEL'=007   'BS '=010   'TAB'=011
'NL '=012   'VT '=013   'FF '=014   'CR '=015   'SO '=016
'SI '=017   'DLE'=020   'DC1'=021   'DC2'=022   'DC3'=023
'DC4'=024   'NAK'=025   'SYN'=026   'ETB'=027   'CAN'=030
'EM '=031   'SUB'=032   'ESC'=033   'FS '=034   'GS '=035
'RS '=036   'US '=037   'SP '=040   '!  '=041   '"  '=042
'#  '=043   '$  '=044   '%  '=045   '&  '=046   "   "
'(  '=050   ')  '=051   '*  '=052   '+  '=053   '   '=
'-  '=055   '.  '=056   '/  '=057   '   '=      '   '=
'   '=      '   '=      '   '=      '   '=      '   '=
'   '=      '   '=      '   '=      ':  '=072   ';  '=073
'LT '=074   '=  '=075   'GT '=076   '?  '=077   '@  '=100
'A  '=101   'B  '=102   'C  '=103   'D  '=104   'E  '=105
'F  '=106   'G  '=107   'H  '=110   'I  '=111   'J  '=112
'K  '=113   'L  '=114   'M  '=115   'N  '=116   'O  '=117
'P  '=120   'Q  '=121   'R  '=122   'S  '=123   'T  '=124
'U  '=125   'V  '=126   'W  '=127   'X  '=130   'Y  '=131
'Z  '=132   '[  '=133   '\  '=134   ']  '=135   '^  '=136
'_  '=137   '   '       'a  '=141   'b  '=142   'c  '=143
'd  '=144   'e  '=145   'f  '=146   'g  '=147   'h  '=150
'i  '=151   'j  '=152   'k  '=153   'l  '=154   'm  '=155
'n  '=156   'o  '=157   'p  '=160   'q  '=161   'r  '=162
's  '=163   't  '=164   'u  '=165   'v  '=166   'w  '=167
'x  '=170   'y  '=171   'z  '=172   '{  '=173   '|  '=174
'}  '=175   '~  '=176   'DEL'=177
C..NP
             Argumente und Adressen

Definition eines Arguments arg:

arg ist ein beliebiger arithmetischer Ausdruck. In bedingten
Anweisungen wird der errechnete Wert des Ausdrucks als logischer
Wert .TRUE. oder .FALSE. interpretiert. Der Wert Null ent-
spricht dem logischen Wert .FALSE. Jeder Wert ungleich Null
entspricht dem logischen .TRUE. In bedingten Ausdrücken dürfen
.T., .F., .Y. und .F. als Argumente angegeben werden. Diese
Werte dürfen ebenfalls als Eingabe in der Input-Anweisung
verwendet werden. Wird als Argument Space oder nichts an-
gegeben, so wird .TRUE. als Argument angenommen.


Definition einer Adresse adr:

Eine Adresse adr ist eine Variable, in die etwas geschrieben
wird.
Die zulässigen Adressen sind im Kapitel über den Variablenvorrat
angegeben.

Form einer arithmetischen Zuweisung:

adr = arg



Liste der bedingten CALC-Anweisungen mit Argumentangaben:

APPEND(  arg ) " Makro-Name "
EXEC  (  arg ) " Programm-Name "
CALL  (  arg ) " Unterprogramm-Name "
STRG  (  arg ) " auszugebender T e x t "
IF    (  arg ) " eine Anweisung "
IF    (  arg ) THEN
ELSEIF(  arg ) THEN
CALL1 (  arg )
CALL2 (  arg )
CALL3 (  arg )
COMMAND( arg ) " T e x t zur COMMAND-Anweisung "
MFORM (  arg ) "(Formatangaben nach FORTRAN-Konvention)"
STOP  (  arg ) " Text zur STOP-Anweisung "
EX_X  (  arg )
EX_Y  (  arg )
EX_Z  (  arg )



Anweisungen mit Adressenangaben:

READ ( adr ) " Daten-Name "
INPUT( adr ) " T e x t zur INPUT-Anweisung "
MPOS ( adr ) " Matrizen-Name oder Daten-Name "
C..NP
             Textvariable und Stringvarible

Textvariable sind in Hochkomma eingeschlossene Buchstaben von
A bis Z oder a bis z. Sie können rechts und links vom Gleichheits-
zeichen auftreten. Textvariable können Text der Länge 0 bis 76
aufnehmen.
Textvariable erhalten ihren Inhalt aus Textvariablen, String-
variablen oder aus speziellen Funktionen.

Stringvariable die der User nicht verändern kann:

USER, REGISTER, VERSION und VIEW.

'A' = User           In 'a' wird der Name des Users abgelegt.
'A' = Register       In 'a' wird die Registriernummer abgelegt.
'A' = Version        In 'a' wird die Programmversion abgelegt.
'A' = View           Der Inhalt von 'a' wird in der Ergebniszeile
                     angezeigt.

Stringvariable die der User verändern kann:

STRING

" T e x t "          Die Stringvariable STRING erhält den Inhalt
                     T e x t . "Text" ist eine Stringanweisung.
'A' = String         In 'a' wird der Inhalt von STRING abgelegt.

Weitere Möglichkeiten Textvariablen Text zuzuweisen:

'a' = ""             'a' wird Text der Länge null zugewiesen.
'b' = "3.141"        'b' wird der Text 3.141 zugewiesen.
'c' = "'a'"          'c' wird der Inhalt von 'a' zugewiesen.
'd' = "Pi = 'b'"     'd' wird der Text 'Pi = ' und der Inhalt von
                     'b' zugewiesen. Ergebnis:  'Pi = 3.141' .

Das Ersetzen einer Textvariablen in einer Stringanweisung durch
ihren Inhalt nennt man Substitution. Die Substitution kann mit
den Anweisungen  SUBON und SUBOFF an- und abgeschaltet werden.
Beim Start von CALC gilt SUBON.

Beispiel:
SUBOFF; 'a' = "'b'"  'a' wird der Text 'b' zugewiesen.
SUBON                Sollte nach SUBOFF nicht vergessen werden !

Beispiel mit mehrstufiger Substitution:
'a' = "Hugo"
SUBOFF
'b' = "'a'"
SUBON
'c' = "'b' ist doof."       'c' erhält den Text 'Hugo ist doof.'
                            Max. 7 Substitutionsstufen werden
                            ausgeführt.

Zweites Beispiel mit mehrstufiger Substitution:
'a' = "Hugo"
'b' = "a"
'c' = "''b'' ist doof."     'c' erhält den Text 'Hugo ist doof.'
C..NP
             Funktionen für Textvariablen

CHAR( 'a', arg )
                Der Textvariablen 'a' wird ein ASCII Zeichen mit
                dem Wert arg zugewiesen. arg ist ein arithm. Aus-
                druck mit dem ganzzahligen Wert 0 bis 255.
                Beispiel: char( 'a', '<nl>' )
                Der Textvariablen 'a' wird das ASCII Zeichen Line-
                feed zugewiesen.

EDIT( 'A',      Aufbereiten n Argumente in der Textvariablen 'a'.
      arg,      In arg steht das Format für die n Argumente.
      arg1,     Die Argumente werden möglichst kurz aufbereitet.
      arg2,     arg ist in der Funktion LISTFM näher beschrieben.
      ... ,     Die Textvariable darf die Länge 76 nicht über-
      argn )    schreiten! In der PD-Version ist arg=0 zu setzen.

EDITFM( 'A',    Aufbereiten n Argumente in der Textvariablen 'a'.
      arg,      In arg steht das Format für die n Argumente.
      arg1,     Die Argumente werden spaltengerecht aufbereitet.
      arg2,     arg ist in der Funktion LISTFM näher beschrieben.
      ... ,     Die Textvariable darf die Länge 76 nicht über-
      argn )    schreiten! In der PD-Version ist arg=0 zu setzen.

EDITMFM( 'A',   Aufbereiten die Argumente arg2, arg4, arg6, ... argn
  arg1, arg2,   in der Textvariablen 'a'. Die Formate stehen in
  arg3, arg4,   arg1, arg3, arg5, ... argn-1. Die Argumente werden
  arg5, arg6,   spaltengerecht aufbereitet. Die Formate sind in der
     .  .  .    Funktion LISTFM näher beschrieben. Die Textvariable
  argn-1,argn ) darf die Länge 76 nicht überschreiten.
                In der PD-Version sind die Formate auf Null zu setzen.

EX_X( arg )     Ausführen Text in der Textvariablen 'x' als An-
                weisung. Es darf nur eine Anweisung in 'x' stehen
                ( kein Semikolon ). Die Anweisung wird nur aus-
                geführt, wenn der Wert von arg ungleich Null ist
                oder arg Space ist.

EX_Y( arg )     Ausführen Text in der Textvariablen 'y' als An-
                weisung. Es darf nur eine Anweisung in 'y' stehen
                ( kein Semikolon ). Die Anweisung wird nur aus-
                geführt, wenn der Wert von arg ungleich Null ist
                oder arg Space ist.

EX_Z( arg )     Ausführen Text in der Textvariablen 'z' als An-
                weisung. Es darf nur eine Anweisung in 'z' stehen
                ( kein Semikolon ). Die Anweisung wird nur aus-
                geführt, wenn der Wert von arg ungleich Null ist
                oder arg Space ist.
C..NP
             Anweisungen mit Textvariablen

In den folgenden Anweisungen sind Textvariable im Stringteil erlaubt:

               " ... 'a' ... "
'A'  =         " ... 'a' ... "
EXEC   ( arg ) " ... 'a' ... "
STRG   ( arg ) " ... 'a' ... "
STOP   ( arg ) " ... 'a' ... "
APPEND ( arg ) " ... 'a' ... "
MFORM  ( arg ) " ... 'a' ... "
COMMAND( arg ) " ... 'a' ... "
MPOS   ( adr ) " ... 'a' ... "
INPUT  ( adr ) " ... 'a' ... "
READ   ( adr ) " ... 'a' ... "


C..NP
             Funktionen für arithmetische AusdrÜcke

Für sämtliche Argumente der unten aufgeführten Funktionen
gilt ohne Ausnahme:  Argumente sind beliebige arithmetische
Ausdrücke aus Konstanten, Variablen und Funktionen.

SQR( arg )      Quadratwurzel berechnen.
                arg >= 0 . Ergebnis positiv.
                Falls arg eine reine Quadratzahl ist, so
                ist das Ergebnis in jedem Fall ganzzahlig.

SIN( arg )      arg beliebig in Grad oder Radian ( Shift F6 ! ).
COS( arg )       "      "    "    "   "     "         "        .
TAN( arg )       "      "    "    "   "     "         "        .

ASIN( arg )     -1 =< arg <= 1   Ergebnis in Grad oder Radian.
ACOS( arg )     -1 =< arg <= 1      "     "    "   "     "   .
ATAN( arg )     arg beliebig        "     "    "   "     "   .

LN( arg )       Natürlicher Logarithmus,  arg > 0.
LOG( arg )      Dekadischer Logarithmus,  arg > 0.

EXP( arg )      E-Funktion, arg beliebig.

K( arg )        Wert des Vektorelementes von K.
                arg ganzzahlig und im Bereich 1 bis 99.

EI( arg )       Eulersche Zahlen Ei. arg = 1, 2, ... , 99.
BI( arg )       Bernoulli Zahlen Bi. arg = 1, 2, ... , 99.

FAK( arg )      Fakultät,  0 =< arg <= 5014,  arg ganzzahlig.

Nuk(arg1,arg2)  Binomialkoeffizienten N über K,
                arg1 >= arg2,   arg1 und arg2 ganzzahlig.

INT( arg )      Ganzzahliger Teil von arg. INT( .9 )   =  0.
                                           INT( -3.7 ) = -3.
ABS( arg )      Absolutbetrag von arg.
NEG( arg )      Negation von arg.

SIGN( arg )     Vorzeichen von arg. Ergebnis ist +1 für arg >= 0
                                    Ergebnis ist -1 für arg <  0

MIN( ... )      Minimum von n Argumenten ( n >= 2 ).
MAX( ... )      Maximum von n Argumenten ( n >= 2 ).

MOD(arg1,arg2)  Modulo-Funktion. arg1, arg2 beliebig. MOD be-
                stimmt den Rest von arg1 = K * arg2 + Rest.
                K ist ganzzahlig.
C..NP
             Ein Beispiel für Tastatureingaben

Die gebrochene Funktion
y = ( 1 + 2 x + 3 x^2 + x^3 ) / ( 1 - pi * x + eu * x^2 )
soll für x = 1, 2, 3, 4 und 5 berechnet und dokumentiert
werden.

Mit den Stackvariablen a und b kann die Funktion in
b = ( 1 + 2*a + 3*a^2 + a^3 ) / ( 1 - pi * a + eu * a^2 )
umgeschrieben werden. Diesen Zeichenstring speichern wir
mit txt1 ab ( Funktionstaste 3 ).

Nun wird mit SHIFT F9 vom List-off Modus in den
List-on Modus geschaltet ( Loff / Lon ). Eine Ausgabe-
datei CALC.LS wird in der aktuellen Userdirectory eröffnet.
Falls die Datei schon existiert, werden eventuelle Aus-
gaben von CALC an die Datei hinzugefügt. Der List-on Modus
darf beliebig oft ein- und ausgeschaltet werden.

Mit call ( F4 ) holen wir den Zeichenstring in die Eingabe-
zeile und speichern ihn mit strg ( F2 ) ab.
Mit Control Delete löschen wir die Eingabezeile und drücken
nochmal strg. Damit haben wir eine Leerzeile ausgegeben.

Mit den folgenden Aktionen wird nun die Funktion mit
15 gültigen Ergebnisstellen dokumentiert.

15 ; 15
Return
SHIFT F8         ( D=15 )
SHIFT F7         ( L=15 )

a = 1
F2               ( strg )
Return
F4               ( call )
Return
F1               ( Erg )

a = 2
F2               ( strg )
Return
F4               ( call )
Return
F1               ( Erg )

usw.  mit a = 3 und a = 4.

Inhalt CALC.LS:

 b = ( 1 + 2*a + 3*a^2 + a^3 ) / ( 1 - pi * a + eu * a^2 )

 a = 1
  .121382545486258E+00002
 a = 2
  .447231831210942E+00001
 a = 3
  .380304977893765E+00001
 a = 4
  .378999794997647E+00001